home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / dev / lang / SmallEiffel.lha / SmallEiffel / bin_c / compile_to_jvm6.c < prev    next >
C/C++ Source or Header  |  1998-12-22  |  19KB  |  951 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.79)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "compile_to_jvm.h"
  9.  
  10.  
  11. T0* r225twin(T225* C){
  12. T0* R=NULL;
  13. R=malloc(sizeof(*C));
  14. *((T225*)R)=M225;
  15. r225copy(((T225*)R),((T0*)C));
  16. return R;
  17. }
  18.  
  19.  
  20. void r225add_last(T225* C,T0* a1){
  21. T2 _new_capacity=0;
  22. /*[IF*/
  23. if(((C)->_capacity/*8*/)<((r225count(C))+(1))){
  24. /*[IF*/
  25. if(((C)->_capacity/*8*/)==(0)){
  26. C->_capacity=16;
  27. C->_storage=calloc((C)->_capacity/*8*/,sizeof(T0*));
  28. }
  29. else{
  30. _new_capacity=(2)*((C)->_capacity/*8*/);
  31. C->_storage=r213realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  32. C->_capacity=_new_capacity;
  33. }
  34. /*FI]*/
  35. }
  36. /*FI]*/
  37. C->_upper=((C)->_upper/*12*/)+(1);
  38. /*[IRF3.6put*/{T225* C1=C;
  39. T0* b1=a1;
  40. T2 b2=(C)->_upper/*12*/;
  41. ((C1)->_storage/*4*/)[(b2)-((C1)->_lower/*16*/)]=(b1);
  42. }/*]*/
  43. }
  44.  
  45.  
  46. T0* r225item(T225* C,T2 a1){
  47. T0* R=NULL;
  48. R=((C)->_storage/*4*/)[(a1)-((C)->_lower/*16*/)];
  49. return R;
  50. }
  51.  
  52.  
  53. T2 r225count(T225* C){
  54. T2 R=0;
  55. R=(((C)->_upper/*12*/)-((C)->_lower/*16*/))+(1);
  56. return R;
  57. }
  58. /*No:ARRAY[MANIFEST_STRING].lower*/
  59. /*No:ARRAY[MANIFEST_STRING].upper*/
  60.  
  61.  
  62. void r225copy(T225* C,T0* a1){
  63. T2 _needed_capacity=0;
  64. C->_lower=(((T225*)a1))->_lower/*16*/;
  65. C->_upper=(((T225*)a1))->_upper/*12*/;
  66. _needed_capacity=(((C)->_upper/*12*/)-((C)->_lower/*16*/))+(1);
  67. /*[IF*/
  68. if(((C)->_capacity/*8*/)<(_needed_capacity)){
  69. C->_capacity=_needed_capacity;
  70. C->_storage=calloc((C)->_capacity/*8*/,sizeof(T0*));
  71. }
  72. /*FI]*/
  73. /*[IF*/
  74. if((_needed_capacity)>(0)){
  75. r213copy_from((C)->_storage/*4*/,(((T225*)a1))->_storage/*4*/,(_needed_capacity)-(1));
  76. }
  77. /*FI]*/
  78. }
  79. /*No:ARRAY[MANIFEST_STRING].capacity*/
  80. /*No:ARRAY[MANIFEST_STRING].put*/
  81. /*No:ARRAY[MANIFEST_STRING].storage*/
  82.  
  83.  
  84. void r381with_capacity(T381* C,T2 a1){
  85. /*[IF*/
  86. if(((C)->_capacity/*8*/)<(a1)){
  87. C->_storage=calloc(a1,sizeof(T0*));
  88. C->_capacity=a1;
  89. }
  90. /*FI]*/
  91. C->_upper=-(1);
  92. }
  93. /*No:FIXED_ARRAY[TYPE_BIT_REF].clear_all*/
  94.  
  95.  
  96. void r381add_last(T381* C,T0* a1){
  97. T2 _new_capacity=0;
  98. /*[IF*/
  99. if((((C)->_upper/*12*/)+(1))<=(((C)->_capacity/*8*/)-(1))){
  100. C->_upper=((C)->_upper/*12*/)+(1);
  101. }
  102.  else if(((C)->_capacity/*8*/)==(0)){
  103. C->_storage=calloc(2,sizeof(T0*));
  104. C->_capacity=2;
  105. C->_upper=0;
  106. }
  107. else{
  108. _new_capacity=(2)*((C)->_capacity/*8*/);
  109. C->_storage=r382realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  110. C->_capacity=_new_capacity;
  111. C->_upper=((C)->_upper/*12*/)+(1);
  112. }
  113. /*FI]*/
  114. /*[IRF3.5put*/((C)->_storage/*4*/)[(C)->_upper/*12*/]=(a1);
  115. /*]*/
  116. }
  117. /*No:FIXED_ARRAY[TYPE_BIT_REF].set_all_with*/
  118. /*No:FIXED_ARRAY[TYPE_BIT_REF].item*/
  119. /*No:FIXED_ARRAY[TYPE_BIT_REF].count*/
  120.  
  121.  
  122. void r381resize(T381* C,T2 a1){
  123. T0* _elt_default=NULL;
  124. T2 _i=0;
  125. T2 _new_capacity=0;
  126. /*[IF*/
  127. if((a1)<=(/*(IRF4.6count*/((C)->_upper/*12*/)+(1)/*)*/)){
  128. C->_upper=(a1)-(1);
  129. }
  130. else{
  131. _new_capacity=a1;
  132. /*[IF*/
  133. if(((C)->_capacity/*8*/)<(_new_capacity)){
  134. /*[IF*/
  135. if(((C)->_capacity/*8*/)==(0)){
  136. C->_storage=calloc(_new_capacity,sizeof(T0*));
  137. }
  138. else{
  139. C->_storage=r382realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  140. }
  141. /*FI]*/
  142. C->_capacity=_new_capacity;
  143. }
  144. /*FI]*/
  145. _new_capacity=(C)->_upper/*12*/;
  146. C->_upper=(a1)-(1);
  147. _i=(C)->_upper/*12*/;
  148. while (!((_i)==(_new_capacity))) {
  149. /*[IRF3.5put*/((C)->_storage/*4*/)[_i]=(_elt_default);
  150. /*]*/
  151. _i=(_i)-(1);
  152. }
  153. }
  154. /*FI]*/
  155. }
  156.  
  157.  
  158. void r381make(T381* C,T2 a1){
  159. /*[IF*/
  160. if((a1)==(0)){
  161. C->_upper=-(1);
  162. }
  163.  else if(((C)->_capacity/*8*/)==(0)){
  164. C->_storage=calloc(a1,sizeof(T0*));
  165. C->_capacity=a1;
  166. C->_upper=(a1)-(1);
  167. }
  168.  else if(((C)->_capacity/*8*/)<(a1)){
  169. C->_storage=calloc(a1,sizeof(T0*));
  170. C->_capacity=a1;
  171. C->_upper=(a1)-(1);
  172. }
  173. else{
  174. C->_upper=(a1)-(1);
  175. /*[IRF3.6clear_all*/{T381* C1=C;
  176. T0* __value=NULL;
  177. /*[IRF3.6set_all_with*/{T381* C2=C1;
  178. T0* c1=__value;
  179. r382set_all_with((C2)->_storage/*4*/,c1,(C2)->_upper/*12*/);
  180. }/*]*/
  181. }/*]*/
  182. }
  183. /*FI]*/
  184. }
  185. /*No:FIXED_ARRAY[TYPE_BIT_REF].upper*/
  186. /*No:FIXED_ARRAY[TYPE_BIT_REF].capacity*/
  187. /*No:FIXED_ARRAY[TYPE_BIT_REF].put*/
  188. /*No:FIXED_ARRAY[TYPE_BIT_REF].storage*/
  189.  
  190.  
  191. void r88with_capacity(T88* C,T2 a1){
  192. /*[IF*/
  193. if(((C)->_capacity/*4*/)<(a1)){
  194. C->_storage=calloc(a1,sizeof(T0*));
  195. C->_capacity=a1;
  196. }
  197. /*FI]*/
  198. C->_upper=-(1);
  199. }
  200. /*No:FIXED_ARRAY[FEATURE_NAME].clear_all*/
  201.  
  202.  
  203. void r88add_last(T88* C,T0* a1){
  204. T2 _new_capacity=0;
  205. /*[IF*/
  206. if((((C)->_upper/*8*/)+(1))<=(((C)->_capacity/*4*/)-(1))){
  207. C->_upper=((C)->_upper/*8*/)+(1);
  208. }
  209.  else if(((C)->_capacity/*4*/)==(0)){
  210. C->_storage=calloc(2,sizeof(T0*));
  211. C->_capacity=2;
  212. C->_upper=0;
  213. }
  214. else{
  215. _new_capacity=(2)*((C)->_capacity/*4*/);
  216. C->_storage=r93realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  217. C->_capacity=_new_capacity;
  218. C->_upper=((C)->_upper/*8*/)+(1);
  219. }
  220. /*FI]*/
  221. /*[IRF3.5put*/((C)->_storage/*0*/)[(C)->_upper/*8*/]=(a1);
  222. /*]*/
  223. }
  224. /*No:FIXED_ARRAY[FEATURE_NAME].set_all_with*/
  225. /*No:FIXED_ARRAY[FEATURE_NAME].item*/
  226. /*No:FIXED_ARRAY[FEATURE_NAME].first*/
  227. /*No:FIXED_ARRAY[FEATURE_NAME].lower*/
  228.  
  229.  
  230. void r88make(T88* C,T2 a1){
  231. /*[IF*/
  232. if((a1)==(0)){
  233. C->_upper=-(1);
  234. }
  235.  else if(((C)->_capacity/*4*/)==(0)){
  236. C->_storage=calloc(a1,sizeof(T0*));
  237. C->_capacity=a1;
  238. C->_upper=(a1)-(1);
  239. }
  240.  else if(((C)->_capacity/*4*/)<(a1)){
  241. C->_storage=calloc(a1,sizeof(T0*));
  242. C->_capacity=a1;
  243. C->_upper=(a1)-(1);
  244. }
  245. else{
  246. C->_upper=(a1)-(1);
  247. /*[IRF3.6clear_all*/{T88* C1=C;
  248. T0* __value=NULL;
  249. /*[IRF3.6set_all_with*/{T88* C2=C1;
  250. T0* c1=__value;
  251. r93set_all_with((C2)->_storage/*0*/,c1,(C2)->_upper/*8*/);
  252. }/*]*/
  253. }/*]*/
  254. }
  255. /*FI]*/
  256. }
  257. /*No:FIXED_ARRAY[FEATURE_NAME].upper*/
  258. /*No:FIXED_ARRAY[FEATURE_NAME].clear*/
  259. /*No:FIXED_ARRAY[FEATURE_NAME].capacity*/
  260. /*No:FIXED_ARRAY[FEATURE_NAME].put*/
  261. /*No:FIXED_ARRAY[FEATURE_NAME].storage*/
  262.  
  263.  
  264. T0* r195twin(T195* C){
  265. T0* R=NULL;
  266. R=malloc(sizeof(*C));
  267. *((T195*)R)=M195;
  268. r195copy(((T195*)R),((T0*)C));
  269. return R;
  270. }
  271. /*No:ARRAY[ARGUMENT_NAME1].clear_all*/
  272.  
  273.  
  274. void r195add_last(T195* C,T0* a1){
  275. T2 _new_capacity=0;
  276. /*[IF*/
  277. if(((C)->_capacity/*8*/)<((r195count(C))+(1))){
  278. /*[IF*/
  279. if(((C)->_capacity/*8*/)==(0)){
  280. C->_capacity=16;
  281. C->_storage=calloc((C)->_capacity/*8*/,sizeof(T0*));
  282. }
  283. else{
  284. _new_capacity=(2)*((C)->_capacity/*8*/);
  285. C->_storage=r196realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  286. C->_capacity=_new_capacity;
  287. }
  288. /*FI]*/
  289. }
  290. /*FI]*/
  291. C->_upper=((C)->_upper/*12*/)+(1);
  292. /*[IRF3.6put*/{T195* C1=C;
  293. T0* b1=a1;
  294. T2 b2=(C)->_upper/*12*/;
  295. ((C1)->_storage/*4*/)[(b2)-((C1)->_lower/*16*/)]=(b1);
  296. }/*]*/
  297. }
  298. /*No:ARRAY[ARGUMENT_NAME1].set_all_with*/
  299.  
  300.  
  301. T0* r195item(T195* C,T2 a1){
  302. T0* R=NULL;
  303. R=((C)->_storage/*4*/)[(a1)-((C)->_lower/*16*/)];
  304. return R;
  305. }
  306.  
  307.  
  308. T0* r195first(T195* C){
  309. T0* R=NULL;
  310. R=r195item(C,(C)->_lower/*16*/);
  311. return R;
  312. }
  313.  
  314.  
  315. T2 r195count(T195* C){
  316. T2 R=0;
  317. R=(((C)->_upper/*12*/)-((C)->_lower/*16*/))+(1);
  318. return R;
  319. }
  320. /*No:ARRAY[ARGUMENT_NAME1].lower*/
  321.  
  322.  
  323. void r195make(T195* C,T2 a1,T2 a2){
  324. T2 _needed=0;
  325. C->_lower=a1;
  326. C->_upper=a2;
  327. _needed=((a2)-(a1))+(1);
  328. /*[IF*/
  329. if((_needed)>(0)){
  330. /*[IF*/
  331. if(((C)->_capacity/*8*/)<(_needed)){
  332. C->_storage=calloc(_needed,sizeof(T0*));
  333. C->_capacity=_needed;
  334. }
  335. else{
  336. /*[IRF3.6clear_all*/{T195* C1=C;
  337. T0* __value=NULL;
  338. /*[IRF3.6set_all_with*/{T195* C2=C1;
  339. T0* c1=__value;
  340. r196set_all_with((C2)->_storage/*4*/,c1,((C2)->_upper/*12*/)-((C2)->_lower/*16*/));
  341. }/*]*/
  342. }/*]*/
  343. }
  344. /*FI]*/
  345. }
  346. /*FI]*/
  347. }
  348. /*No:ARRAY[ARGUMENT_NAME1].upper*/
  349.  
  350.  
  351. void r195copy(T195* C,T0* a1){
  352. T2 _needed_capacity=0;
  353. C->_lower=(((T195*)a1))->_lower/*16*/;
  354. C->_upper=(((T195*)a1))->_upper/*12*/;
  355. _needed_capacity=(((C)->_upper/*12*/)-((C)->_lower/*16*/))+(1);
  356. /*[IF*/
  357. if(((C)->_capacity/*8*/)<(_needed_capacity)){
  358. C->_capacity=_needed_capacity;
  359. C->_storage=calloc((C)->_capacity/*8*/,sizeof(T0*));
  360. }
  361. /*FI]*/
  362. /*[IF*/
  363. if((_needed_capacity)>(0)){
  364. r196copy_from((C)->_storage/*4*/,(((T195*)a1))->_storage/*4*/,(_needed_capacity)-(1));
  365. }
  366. /*FI]*/
  367. }
  368. /*No:ARRAY[ARGUMENT_NAME1].capacity*/
  369. /*No:ARRAY[ARGUMENT_NAME1].put*/
  370. /*No:ARRAY[ARGUMENT_NAME1].storage*/
  371.  
  372.  
  373. void r99add_last(T99* C,T0* a1){
  374. T2 _new_capacity=0;
  375. /*[IF*/
  376. if(((C)->_capacity/*4*/)<((r99count(C))+(1))){
  377. /*[IF*/
  378. if(((C)->_capacity/*4*/)==(0)){
  379. C->_capacity=16;
  380. C->_storage=calloc((C)->_capacity/*4*/,sizeof(T0*));
  381. }
  382. else{
  383. _new_capacity=(2)*((C)->_capacity/*4*/);
  384. C->_storage=r100realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  385. C->_capacity=_new_capacity;
  386. }
  387. /*FI]*/
  388. }
  389. /*FI]*/
  390. C->_upper=((C)->_upper/*8*/)+(1);
  391. /*[IRF3.6put*/{T99* C1=C;
  392. T0* b1=a1;
  393. T2 b2=(C)->_upper/*8*/;
  394. ((C1)->_storage/*0*/)[(b2)-((C1)->_lower/*12*/)]=(b1);
  395. }/*]*/
  396. }
  397.  
  398.  
  399. T0* r99item(T99* C,T2 a1){
  400. T0* R=NULL;
  401. R=((C)->_storage/*0*/)[(a1)-((C)->_lower/*12*/)];
  402. return R;
  403. }
  404.  
  405.  
  406. T2 r99count(T99* C){
  407. T2 R=0;
  408. R=(((C)->_upper/*8*/)-((C)->_lower/*12*/))+(1);
  409. return R;
  410. }
  411. /*No:ARRAY[FEATURE_CLAUSE].lower*/
  412. /*No:ARRAY[FEATURE_CLAUSE].upper*/
  413. /*No:ARRAY[FEATURE_CLAUSE].capacity*/
  414. /*No:ARRAY[FEATURE_CLAUSE].put*/
  415. /*No:ARRAY[FEATURE_CLAUSE].storage*/
  416.  
  417.  
  418. void r206with_capacity(T206* C,T2 a1){
  419. /*[IF*/
  420. if(((C)->_capacity/*8*/)<(a1)){
  421. C->_storage=calloc(a1,sizeof(T0*));
  422. C->_capacity=a1;
  423. }
  424. /*FI]*/
  425. C->_upper=-(1);
  426. }
  427.  
  428.  
  429. T0* r206twin(T206* C){
  430. T0* R=NULL;
  431. R=malloc(sizeof(*C));
  432. *((T206*)R)=M206;
  433. r206copy(((T206*)R),((T0*)C));
  434. return R;
  435. }
  436. /*No:FIXED_ARRAY[INTEGER_CONSTANT].clear_all*/
  437.  
  438.  
  439. void r206add_last(T206* C,T0* a1){
  440. T2 _new_capacity=0;
  441. /*[IF*/
  442. if((((C)->_upper/*12*/)+(1))<=(((C)->_capacity/*8*/)-(1))){
  443. C->_upper=((C)->_upper/*12*/)+(1);
  444. }
  445.  else if(((C)->_capacity/*8*/)==(0)){
  446. C->_storage=calloc(2,sizeof(T0*));
  447. C->_capacity=2;
  448. C->_upper=0;
  449. }
  450. else{
  451. _new_capacity=(2)*((C)->_capacity/*8*/);
  452. C->_storage=r207realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  453. C->_capacity=_new_capacity;
  454. C->_upper=((C)->_upper/*12*/)+(1);
  455. }
  456. /*FI]*/
  457. /*[IRF3.5put*/((C)->_storage/*4*/)[(C)->_upper/*12*/]=(a1);
  458. /*]*/
  459. }
  460. /*No:FIXED_ARRAY[INTEGER_CONSTANT].item*/
  461. /*No:FIXED_ARRAY[INTEGER_CONSTANT].set_all_with*/
  462. /*No:FIXED_ARRAY[INTEGER_CONSTANT].count*/
  463.  
  464.  
  465. void r206resize(T206* C,T2 a1){
  466. T0* _elt_default=NULL;
  467. T2 _i=0;
  468. T2 _new_capacity=0;
  469. /*[IF*/
  470. if((a1)<=(/*(IRF4.6count*/((C)->_upper/*12*/)+(1)/*)*/)){
  471. C->_upper=(a1)-(1);
  472. }
  473. else{
  474. _new_capacity=a1;
  475. /*[IF*/
  476. if(((C)->_capacity/*8*/)<(_new_capacity)){
  477. /*[IF*/
  478. if(((C)->_capacity/*8*/)==(0)){
  479. C->_storage=calloc(_new_capacity,sizeof(T0*));
  480. }
  481. else{
  482. C->_storage=r207realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  483. }
  484. /*FI]*/
  485. C->_capacity=_new_capacity;
  486. }
  487. /*FI]*/
  488. _new_capacity=(C)->_upper/*12*/;
  489. C->_upper=(a1)-(1);
  490. _i=(C)->_upper/*12*/;
  491. while (!((_i)==(_new_capacity))) {
  492. /*[IRF3.5put*/((C)->_storage/*4*/)[_i]=(_elt_default);
  493. /*]*/
  494. _i=(_i)-(1);
  495. }
  496. }
  497. /*FI]*/
  498. }
  499.  
  500.  
  501. void r206make(T206* C,T2 a1){
  502. /*[IF*/
  503. if((a1)==(0)){
  504. C->_upper=-(1);
  505. }
  506.  else if(((C)->_capacity/*8*/)==(0)){
  507. C->_storage=calloc(a1,sizeof(T0*));
  508. C->_capacity=a1;
  509. C->_upper=(a1)-(1);
  510. }
  511.  else if(((C)->_capacity/*8*/)<(a1)){
  512. C->_storage=calloc(a1,sizeof(T0*));
  513. C->_capacity=a1;
  514. C->_upper=(a1)-(1);
  515. }
  516. else{
  517. C->_upper=(a1)-(1);
  518. /*[IRF3.6clear_all*/{T206* C1=C;
  519. T0* __value=NULL;
  520. /*[IRF3.6set_all_with*/{T206* C2=C1;
  521. T0* c1=__value;
  522. r207set_all_with((C2)->_storage/*4*/,c1,(C2)->_upper/*12*/);
  523. }/*]*/
  524. }/*]*/
  525. }
  526. /*FI]*/
  527. }
  528. /*No:FIXED_ARRAY[INTEGER_CONSTANT].upper*/
  529.  
  530.  
  531. void r206copy(T206* C,T0* a1){
  532. T2 _new_capacity=0;
  533. T2 _other_upper=0;
  534. _other_upper=(((T206*)a1))->_upper/*12*/;
  535. /*[IF*/
  536. if((_other_upper)>=(0)){
  537. _new_capacity=(_other_upper)+(1);
  538. /*[IF*/
  539. if(((C)->_capacity/*8*/)<(_new_capacity)){
  540. C->_capacity=_new_capacity;
  541. C->_storage=calloc(_new_capacity,sizeof(T0*));
  542. }
  543.  else if(((C)->_capacity/*8*/)>(0)){
  544. r207clear_all((C)->_storage/*4*/,((C)->_capacity/*8*/)-(1));
  545. }
  546. /*FI]*/
  547. r207copy_from((C)->_storage/*4*/,(((T206*)a1))->_storage/*4*/,_other_upper);
  548. }
  549.  else if(((C)->_capacity/*8*/)>(0)){
  550. r207clear_all((C)->_storage/*4*/,((C)->_capacity/*8*/)-(1));
  551. }
  552. /*FI]*/
  553. C->_upper=_other_upper;
  554. }
  555. /*No:FIXED_ARRAY[INTEGER_CONSTANT].capacity*/
  556. /*No:FIXED_ARRAY[INTEGER_CONSTANT].storage*/
  557. /*No:FIXED_ARRAY[INTEGER_CONSTANT].put*/
  558.  
  559.  
  560. T0* r265twin(T265* C){
  561. T0* R=NULL;
  562. R=malloc(sizeof(*C));
  563. *((T265*)R)=M265;
  564. r265copy(((T265*)R),((T0*)C));
  565. return R;
  566. }
  567.  
  568.  
  569. void r265add_last(T265* C,T0* a1){
  570. T2 _new_capacity=0;
  571. /*[IF*/
  572. if(((C)->_capacity/*4*/)<((r265count(C))+(1))){
  573. /*[IF*/
  574. if(((C)->_capacity/*4*/)==(0)){
  575. C->_capacity=16;
  576. C->_storage=calloc((C)->_capacity/*4*/,sizeof(T0*));
  577. }
  578. else{
  579. _new_capacity=(2)*((C)->_capacity/*4*/);
  580. C->_storage=r266realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  581. C->_capacity=_new_capacity;
  582. }
  583. /*FI]*/
  584. }
  585. /*FI]*/
  586. C->_upper=((C)->_upper/*8*/)+(1);
  587. /*[IRF3.6put*/{T265* C1=C;
  588. T0* b1=a1;
  589. T2 b2=(C)->_upper/*8*/;
  590. ((C1)->_storage/*0*/)[(b2)-((C1)->_lower/*12*/)]=(b1);
  591. }/*]*/
  592. }
  593.  
  594.  
  595. T0* r265item(T265* C,T2 a1){
  596. T0* R=NULL;
  597. R=((C)->_storage/*0*/)[(a1)-((C)->_lower/*12*/)];
  598. return R;
  599. }
  600.  
  601.  
  602. T0* r265first(T265* C){
  603. T0* R=NULL;
  604. R=r265item(C,(C)->_lower/*12*/);
  605. return R;
  606. }
  607.  
  608.  
  609. T2 r265count(T265* C){
  610. T2 R=0;
  611. R=(((C)->_upper/*8*/)-((C)->_lower/*12*/))+(1);
  612. return R;
  613. }
  614. /*No:ARRAY[TYPE].lower*/
  615. /*No:ARRAY[TYPE].upper*/
  616.  
  617.  
  618. void r265copy(T265* C,T0* a1){
  619. T2 _needed_capacity=0;
  620. C->_lower=(((T265*)a1))->_lower/*12*/;
  621. C->_upper=(((T265*)a1))->_upper/*8*/;
  622. _needed_capacity=(((C)->_upper/*8*/)-((C)->_lower/*12*/))+(1);
  623. /*[IF*/
  624. if(((C)->_capacity/*4*/)<(_needed_capacity)){
  625. C->_capacity=_needed_capacity;
  626. C->_storage=calloc((C)->_capacity/*4*/,sizeof(T0*));
  627. }
  628. /*FI]*/
  629. /*[IF*/
  630. if((_needed_capacity)>(0)){
  631. r266copy_from((C)->_storage/*0*/,(((T265*)a1))->_storage/*0*/,(_needed_capacity)-(1));
  632. }
  633. /*FI]*/
  634. }
  635. /*No:ARRAY[TYPE].capacity*/
  636. /*No:ARRAY[TYPE].put*/
  637. /*No:ARRAY[TYPE].storage*/
  638.  
  639.  
  640. void r48with_capacity(T48* C,T2 a1){
  641. /*[IF*/
  642. if(((C)->_capacity/*4*/)<(a1)){
  643. C->_storage=calloc(a1,sizeof(T2));
  644. C->_capacity=a1;
  645. }
  646. /*FI]*/
  647. C->_upper=-(1);
  648. }
  649. /*No:FIXED_ARRAY[INTEGER].clear_all*/
  650.  
  651.  
  652. void r48add_last(T48* C,T2 a1){
  653. T2 _new_capacity=0;
  654. /*[IF*/
  655. if((((C)->_upper/*8*/)+(1))<=(((C)->_capacity/*4*/)-(1))){
  656. C->_upper=((C)->_upper/*8*/)+(1);
  657. }
  658.  else if(((C)->_capacity/*4*/)==(0)){
  659. C->_storage=calloc(2,sizeof(T2));
  660. C->_capacity=2;
  661. C->_upper=0;
  662. }
  663. else{
  664. _new_capacity=(2)*((C)->_capacity/*4*/);
  665. C->_storage=r49realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  666. C->_capacity=_new_capacity;
  667. C->_upper=((C)->_upper/*8*/)+(1);
  668. }
  669. /*FI]*/
  670. /*[IRF3.5put*/((C)->_storage/*0*/)[(C)->_upper/*8*/]=(a1);
  671. /*]*/
  672. }
  673. /*No:FIXED_ARRAY[INTEGER].set_all_with*/
  674. /*No:FIXED_ARRAY[INTEGER].item*/
  675.  
  676.  
  677. T6 r48valid_index(T48* C,T2 a1){
  678. T6 R=0;
  679. R=((0)<=(a1))&&((a1)<=((C)->_upper/*8*/));
  680. return R;
  681. }
  682. /*No:FIXED_ARRAY[INTEGER].lower*/
  683. /*No:FIXED_ARRAY[INTEGER].count*/
  684.  
  685.  
  686. void r48resize(T48* C,T2 a1){
  687. T2 _elt_default=0;
  688. T2 _i=0;
  689. T2 _new_capacity=0;
  690. /*[IF*/
  691. if((a1)<=(/*(IRF4.6count*/((C)->_upper/*8*/)+(1)/*)*/)){
  692. C->_upper=(a1)-(1);
  693. }
  694. else{
  695. _new_capacity=a1;
  696. /*[IF*/
  697. if(((C)->_capacity/*4*/)<(_new_capacity)){
  698. /*[IF*/
  699. if(((C)->_capacity/*4*/)==(0)){
  700. C->_storage=calloc(_new_capacity,sizeof(T2));
  701. }
  702. else{
  703. C->_storage=r49realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  704. }
  705. /*FI]*/
  706. C->_capacity=_new_capacity;
  707. }
  708. /*FI]*/
  709. _new_capacity=(C)->_upper/*8*/;
  710. C->_upper=(a1)-(1);
  711. _i=(C)->_upper/*8*/;
  712. while (!((_i)==(_new_capacity))) {
  713. /*[IRF3.5put*/((C)->_storage/*0*/)[_i]=(_elt_default);
  714. /*]*/
  715. _i=(_i)-(1);
  716. }
  717. }
  718. /*FI]*/
  719. }
  720.  
  721.  
  722. T6 r48fast_has(T48* C,T2 a1){
  723. T6 R=0;
  724. R=r48valid_index(C,r48fast_index_of(C,a1));
  725. return R;
  726. }
  727.  
  728.  
  729. void r48make(T48* C,T2 a1){
  730. /*[IF*/
  731. if((a1)==(0)){
  732. C->_upper=-(1);
  733. }
  734.  else if(((C)->_capacity/*4*/)==(0)){
  735. C->_storage=calloc(a1,sizeof(T2));
  736. C->_capacity=a1;
  737. C->_upper=(a1)-(1);
  738. }
  739.  else if(((C)->_capacity/*4*/)<(a1)){
  740. C->_storage=calloc(a1,sizeof(T2));
  741. C->_capacity=a1;
  742. C->_upper=(a1)-(1);
  743. }
  744. else{
  745. C->_upper=(a1)-(1);
  746. /*[IRF3.6clear_all*/{T48* C1=C;
  747. T2 __value=0;
  748. /*[IRF3.6set_all_with*/{T48* C2=C1;
  749. T2 c1=__value;
  750. r49set_all_with((C2)->_storage/*0*/,c1,(C2)->_upper/*8*/);
  751. }/*]*/
  752. }/*]*/
  753. }
  754. /*FI]*/
  755. }
  756.  
  757.  
  758. T2 r48fast_index_of(T48* C,T2 a1){
  759. T2 R=0;
  760. R=r49fast_index_of((C)->_storage/*0*/,a1,(C)->_upper/*8*/);
  761. return R;
  762. }
  763. /*No:FIXED_ARRAY[INTEGER].upper*/
  764. /*No:FIXED_ARRAY[INTEGER].clear*/
  765. /*No:FIXED_ARRAY[INTEGER].capacity*/
  766. /*No:FIXED_ARRAY[INTEGER].put*/
  767. /*No:FIXED_ARRAY[INTEGER].storage*/
  768. /*No:FIXED_ARRAY[CP_INFO].clear_all*/
  769.  
  770.  
  771. void r44add_last(T44* C,T0* a1){
  772. T2 _new_capacity=0;
  773. /*[IF*/
  774. if((((C)->_upper/*8*/)+(1))<=(((C)->_capacity/*4*/)-(1))){
  775. C->_upper=((C)->_upper/*8*/)+(1);
  776. }
  777.  else if(((C)->_capacity/*4*/)==(0)){
  778. C->_storage=calloc(2,sizeof(T0*));
  779. C->_capacity=2;
  780. C->_upper=0;
  781. }
  782. else{
  783. _new_capacity=(2)*((C)->_capacity/*4*/);
  784. C->_storage=r46realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  785. C->_capacity=_new_capacity;
  786. C->_upper=((C)->_upper/*8*/)+(1);
  787. }
  788. /*FI]*/
  789. /*[IRF3.5put*/((C)->_storage/*0*/)[(C)->_upper/*8*/]=(a1);
  790. /*]*/
  791. }
  792. /*No:FIXED_ARRAY[CP_INFO].item*/
  793. /*No:FIXED_ARRAY[CP_INFO].set_all_with*/
  794.  
  795.  
  796. void r44make(T44* C,T2 a1){
  797. /*[IF*/
  798. if((a1)==(0)){
  799. C->_upper=-(1);
  800. }
  801.  else if(((C)->_capacity/*4*/)==(0)){
  802. C->_storage=calloc(a1,sizeof(T0*));
  803. C->_capacity=a1;
  804. C->_upper=(a1)-(1);
  805. }
  806.  else if(((C)->_capacity/*4*/)<(a1)){
  807. C->_storage=calloc(a1,sizeof(T0*));
  808. C->_capacity=a1;
  809. C->_upper=(a1)-(1);
  810. }
  811. else{
  812. C->_upper=(a1)-(1);
  813. /*[IRF3.6clear_all*/{T44* C1=C;
  814. T0* __value=NULL;
  815. /*[IRF3.6set_all_with*/{T44* C2=C1;
  816. T0* c1=__value;
  817. r46set_all_with((C2)->_storage/*0*/,c1,(C2)->_upper/*8*/);
  818. }/*]*/
  819. }/*]*/
  820. }
  821. /*FI]*/
  822. }
  823. /*No:FIXED_ARRAY[CP_INFO].upper*/
  824. /*No:FIXED_ARRAY[CP_INFO].capacity*/
  825. /*No:FIXED_ARRAY[CP_INFO].put*/
  826. /*No:FIXED_ARRAY[CP_INFO].storage*/
  827.  
  828.  
  829. void r359clear_all(T359* C){
  830. T0* _value=NULL;
  831. /*[IRF3.6set_all_with*/{T359* C1=C;
  832. T0* b1=_value;
  833. r56set_all_with((C1)->_storage/*4*/,b1,((C1)->_upper/*12*/)-((C1)->_lower/*16*/));
  834. }/*]*/
  835. }
  836.  
  837.  
  838. void r359force(T359* C,T0* a1,T2 a2){
  839. /*[IF*/
  840. if(((C)->_upper/*12*/)<(a2)){
  841. r359resize(C,(C)->_lower/*16*/,a2);
  842. }
  843.  else if((a2)<((C)->_lower/*16*/)){
  844. r359resize(C,a2,(C)->_upper/*12*/);
  845. }
  846. /*FI]*/
  847. /*[IRF3.6put*/{T359* C1=C;
  848. T0* b1=a1;
  849. T2 b2=a2;
  850. ((C1)->_storage/*4*/)[(b2)-((C1)->_lower/*16*/)]=(b1);
  851. }/*]*/
  852. }
  853.  
  854.  
  855. T0* r359item(T359* C,T2 a1){
  856. T0* R=NULL;
  857. R=((C)->_storage/*4*/)[(a1)-((C)->_lower/*16*/)];
  858. return R;
  859. }
  860. /*No:ARRAY[RUN_FEATURE].set_all_with*/
  861. /*No:ARRAY[RUN_FEATURE].lower*/
  862.  
  863.  
  864. void r359resize(T359* C,T2 a1,T2 a2){
  865. T2 _intersize=0;
  866. T2 _offset=0;
  867. T2 _needed=0;
  868. _needed=((a2)-(a1))+(1);
  869. /*[IF*/
  870. if((_needed)>(0)){
  871. /*[IF*/
  872. if((_needed)>((C)->_capacity/*8*/)){
  873. /*[IF*/
  874. if(((C)->_capacity/*8*/)==(0)){
  875. C->_storage=calloc(_needed,sizeof(T0*));
  876. C->_capacity=_needed;
  877. }
  878. else{
  879. C->_storage=r56realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_needed);
  880. C->_capacity=_needed;
  881. }
  882. /*FI]*/
  883. }
  884. /*FI]*/
  885. _offset=((C)->_lower/*16*/)-(a1);
  886. _intersize=((r2min(a2,(C)->_upper/*12*/))-(r2max(a1,(C)->_lower/*16*/)))+(1);
  887. /*[IF*/
  888. if((_intersize)>(0)){
  889. /*[IF*/
  890. if((_offset)==(0)){
  891. /*[IF*/
  892. if((_intersize)<(_needed)){
  893. r56clear((C)->_storage/*4*/,_intersize,(_needed)-(1));
  894. }
  895. /*FI]*/
  896. }
  897.  else if((_offset)<(0)){
  898. r56move((C)->_storage/*4*/,-(_offset),((_intersize)-(_offset))-(1),_offset);
  899. /*[IF*/
  900. if((_intersize)<(_needed)){
  901. r56clear((C)->_storage/*4*/,_intersize,(_needed)-(1));
  902. }
  903. /*FI]*/
  904. }
  905. else{
  906. r56move((C)->_storage/*4*/,0,(_intersize)-(1),_offset);
  907. r56clear((C)->_storage/*4*/,0,(_offset)-(1));
  908. /*[IF*/
  909. if(((_intersize)+(_offset))<(_needed)){
  910. r56clear((C)->_storage/*4*/,(_intersize)+(_offset),(_needed)-(1));
  911. }
  912. /*FI]*/
  913. }
  914. /*FI]*/
  915. }
  916. else{
  917. r56clear((C)->_storage/*4*/,0,(_needed)-(1));
  918. }
  919. /*FI]*/
  920. }
  921. /*FI]*/
  922. C->_lower=a1;
  923. C->_upper=a2;
  924. }
  925.  
  926.  
  927. void r359make(T359* C,T2 a1,T2 a2){
  928. T2 _needed=0;
  929. C->_lower=a1;
  930. C->_upper=a2;
  931. _needed=((a2)-(a1))+(1);
  932. /*[IF*/
  933. if((_needed)>(0)){
  934. /*[IF*/
  935. if(((C)->_capacity/*8*/)<(_needed)){
  936. C->_storage=calloc(_needed,sizeof(T0*));
  937. C->_capacity=_needed;
  938. }
  939. else{
  940. r359clear_all(C);
  941. }
  942. /*FI]*/
  943. }
  944. /*FI]*/
  945. }
  946. /*No:ARRAY[RUN_FEATURE].upper*/
  947. /*No:ARRAY[RUN_FEATURE].capacity*/
  948. /*No:ARRAY[RUN_FEATURE].put*/
  949. /*No:ARRAY[RUN_FEATURE].storage*/
  950.  
  951.